home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / searchtools / look.c < prev    next >
C/C++ Source or Header  |  1994-08-01  |  3KB  |  185 lines
  1. static char *sccsid = "@(#)look.c 4.2.olson (From UC Berkeley) 13 Nov.  83";
  2. /* altered to allow multiple files for lookup. fortune!olson */
  3. #include <stdio.h>
  4. #include <ctype.h>
  5.  
  6. FILE *dfile;
  7. /* default dictionary (/usr/dict for v7 or bsd) */
  8. #define DICT "/usr/lib/dict/words"
  9.  
  10. int fold;
  11. int dict;
  12. int tab;
  13. char entry[250];
  14. char word[250];
  15. char key[50];
  16. char *search;
  17. long top,bot,mid;
  18.  
  19. main(argc,argv)
  20. char **argv;
  21. {
  22.     while(argc>=2 && *argv[1]=='-') {
  23.         for(;;) {
  24.             switch(*++argv[1]) {
  25.             case 'd':
  26.                 dict++;
  27.                 continue;
  28.             case 'f':
  29.                 fold++;
  30.                 continue;
  31.             case 't':
  32.                 tab = argv[1][1];
  33.                 if(tab)
  34.                     ++argv[1];
  35.                 continue;
  36.             case 0:
  37.                 break;
  38.             default:
  39.                 continue;
  40.             }
  41.             break;
  42.         }
  43.         argc --;
  44.         argv++;
  45.     }
  46.     if(argc<=1) {
  47.         fprintf(stderr, "Usage: %s [-f(old)] [-d(ict only)] [-t(abchar) c] word [sortedfile ...]\n",
  48.             argv[0]);
  49.         return 1;
  50.     }
  51.  
  52.     search = argv[1];
  53.  
  54.     if(argc==2) {
  55.         fold++;
  56.         dict++;
  57.         lookup(DICT);
  58.     }
  59.     else {
  60.         register i;
  61.         for(i=2;argv[i];i++)
  62.             lookup(argv[i]);
  63.     }
  64.     exit(0);
  65. }
  66.  
  67.  
  68. lookup(filenam)
  69. char *filenam;
  70. {
  71.     register c;
  72.  
  73.     if(dfile)
  74.         fclose(dfile);
  75.  
  76.     dfile = fopen(filenam,"r");
  77.     if(dfile==NULL) {
  78.         fprintf(stderr,"look: can't open %s\n",filenam);
  79.         return(2);
  80.     }
  81.     canon(search,key);
  82.     bot = 0;
  83.     fseek(dfile,0L,2);
  84.     top = ftell(dfile);
  85.     for(;;) {
  86.         mid = (top+bot)/2;
  87.         fseek(dfile,mid,0);
  88.         do {
  89.             c = getc(dfile);
  90.             mid++;
  91.         } while(c!=EOF && c!='\n');
  92.         if(!getword(entry))
  93.             break;
  94.         canon(entry,word);
  95.         switch(compare(key,word)) {
  96.         case -2:
  97.         case -1:
  98.         case 0:
  99.             if(top<=mid)
  100.                 break;
  101.             top = mid;
  102.             continue;
  103.         case 1:
  104.         case 2:
  105.             bot = mid;
  106.             continue;
  107.         }
  108.         break;
  109.     }
  110.     fseek(dfile,bot,0);
  111.     while(ftell(dfile)<top) {
  112.         if(!getword(entry))
  113.             return;
  114.         canon(entry,word);
  115.         switch(compare(key,word)) {
  116.         case -2:
  117.             return;
  118.         case -1:
  119.         case 0:
  120.             puts(entry);
  121.             break;
  122.         case 1:
  123.         case 2:
  124.             continue;
  125.         }
  126.         break;
  127.     }
  128.     while(getword(entry)) {
  129.         canon(entry,word);
  130.         switch(compare(key,word)) {
  131.         case -1:
  132.         case 0:
  133.             puts(entry);
  134.             continue;
  135.         }
  136.         break;
  137.     }
  138. }
  139.  
  140. compare(s,t)
  141. register char *s,*t;
  142. {
  143.     for(;*s==*t;s++,t++)
  144.         if(*s==0)
  145.             return(0);
  146.     return(*s==0? -1:
  147.         *t==0? 1:
  148.         *s<*t? -2:
  149.         2);
  150. }
  151.  
  152. getword(w)
  153. char *w;
  154. {
  155.     register c;
  156.     for(;;) {
  157.         c = getc(dfile);
  158.         if(c==EOF)
  159.             return(0);
  160.         if(c=='\n')
  161.             break;
  162.         *w++ = c;
  163.     }
  164.     *w = 0;
  165.     return(1);
  166. }
  167.  
  168. canon(old,new)
  169. char *old,*new;
  170. {
  171.     register c;
  172.     for(;;) {
  173.         *new = c = *old++;
  174.         if(c==0||c==tab) {
  175.             *new = 0;
  176.             break;
  177.         }
  178.         if(dict && !isalnum(c))
  179.             continue;
  180.         if(fold && isupper(c))
  181.             *new = tolower(c);
  182.         new++;
  183.     }
  184. }
  185.